package com.logicfish.wpbench2.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import com.logicfish.wpbench2.services.WpBenchGrammarAccess;
import com.logicfish.wpbench2.wpBench.ActionType;
import com.logicfish.wpbench2.wpBench.AdminPage;
import com.logicfish.wpbench2.wpBench.BooleanOption;
import com.logicfish.wpbench2.wpBench.ChoiceFn;
import com.logicfish.wpbench2.wpBench.ChoiceOption;
import com.logicfish.wpbench2.wpBench.ChoiceParam;
import com.logicfish.wpbench2.wpBench.ColourOption;
import com.logicfish.wpbench2.wpBench.CustomOption;
import com.logicfish.wpbench2.wpBench.CustomParam;
import com.logicfish.wpbench2.wpBench.CustomParamFn;
import com.logicfish.wpbench2.wpBench.DateOption;
import com.logicfish.wpbench2.wpBench.DefaultOptionParam;
import com.logicfish.wpbench2.wpBench.FilterType;
import com.logicfish.wpbench2.wpBench.FloatOption;
import com.logicfish.wpbench2.wpBench.Function;
import com.logicfish.wpbench2.wpBench.FunctionArgumentList;
import com.logicfish.wpbench2.wpBench.IntegerOption;
import com.logicfish.wpbench2.wpBench.Option;
import com.logicfish.wpbench2.wpBench.Options;
import com.logicfish.wpbench2.wpBench.OptionsPage;
import com.logicfish.wpbench2.wpBench.PlainType;
import com.logicfish.wpbench2.wpBench.Plugin;
import com.logicfish.wpbench2.wpBench.RangeOption;
import com.logicfish.wpbench2.wpBench.SelectOption;
import com.logicfish.wpbench2.wpBench.SelectParam;
import com.logicfish.wpbench2.wpBench.ShortcodeType;
import com.logicfish.wpbench2.wpBench.StringOption;
import com.logicfish.wpbench2.wpBench.StringParam;
import com.logicfish.wpbench2.wpBench.TextOption;
import com.logicfish.wpbench2.wpBench.TextParam;
import com.logicfish.wpbench2.wpBench.URLOption;
import com.logicfish.wpbench2.wpBench.WpBenchPackage;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public class WpBenchSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private WpBenchGrammarAccess grammarAccess;
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == WpBenchPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case WpBenchPackage.ACTION_TYPE:
				if(context == grammarAccess.getActionTypeRule() ||
				   context == grammarAccess.getFunctionTypeRule()) {
					sequence_ActionType(context, (ActionType) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.ADMIN_PAGE:
				if(context == grammarAccess.getAdminPageRule()) {
					sequence_AdminPage(context, (AdminPage) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.BOOLEAN_OPTION:
				if(context == grammarAccess.getBooleanOptionRule() ||
				   context == grammarAccess.getOptionTypeRule()) {
					sequence_BooleanOption(context, (BooleanOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.CHOICE_FN:
				if(context == grammarAccess.getChoiceFnRule()) {
					sequence_ChoiceFn(context, (ChoiceFn) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.CHOICE_OPTION:
				if(context == grammarAccess.getChoiceOptionRule() ||
				   context == grammarAccess.getMultiChoiceOptionRule() ||
				   context == grammarAccess.getOptionTypeRule()) {
					sequence_ChoiceOption(context, (ChoiceOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.CHOICE_PARAM:
				if(context == grammarAccess.getAbstractParamRule() ||
				   context == grammarAccess.getChoiceParamRule()) {
					sequence_ChoiceParam(context, (ChoiceParam) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.COLOUR_OPTION:
				if(context == grammarAccess.getColourOptionRule() ||
				   context == grammarAccess.getOptionTypeRule()) {
					sequence_ColourOption(context, (ColourOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.CUSTOM_OPTION:
				if(context == grammarAccess.getCustomOptionRule() ||
				   context == grammarAccess.getOptionTypeRule()) {
					sequence_CustomOption(context, (CustomOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.CUSTOM_PARAM:
				if(context == grammarAccess.getAbstractParamRule() ||
				   context == grammarAccess.getCustomParamRule()) {
					sequence_CustomParam(context, (CustomParam) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.CUSTOM_PARAM_FN:
				if(context == grammarAccess.getCustomParamFnRule()) {
					sequence_CustomParamFn(context, (CustomParamFn) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.DATE_OPTION:
				if(context == grammarAccess.getDateOptionRule() ||
				   context == grammarAccess.getOptionTypeRule()) {
					sequence_DateOption(context, (DateOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.DEFAULT_OPTION_PARAM:
				if(context == grammarAccess.getAbstractParamRule() ||
				   context == grammarAccess.getAbstractStringParamRule() ||
				   context == grammarAccess.getBooleanParamRule() ||
				   context == grammarAccess.getChoiceParamRule() ||
				   context == grammarAccess.getColourParamRule() ||
				   context == grammarAccess.getCustomParamRule() ||
				   context == grammarAccess.getDateParamRule() ||
				   context == grammarAccess.getDefaultOptionParamRule() ||
				   context == grammarAccess.getFloatParamRule() ||
				   context == grammarAccess.getIntegerParamRule() ||
				   context == grammarAccess.getRangeParamRule() ||
				   context == grammarAccess.getSelectParamRule() ||
				   context == grammarAccess.getStringParamRule() ||
				   context == grammarAccess.getTextParamRule() ||
				   context == grammarAccess.getURLParamRule()) {
					sequence_DefaultOptionParam(context, (DefaultOptionParam) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.FILTER_TYPE:
				if(context == grammarAccess.getFilterTypeRule() ||
				   context == grammarAccess.getFunctionTypeRule()) {
					sequence_FilterType(context, (FilterType) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.FLOAT_OPTION:
				if(context == grammarAccess.getFloatOptionRule() ||
				   context == grammarAccess.getOptionTypeRule()) {
					sequence_FloatOption(context, (FloatOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.FUNCTION:
				if(context == grammarAccess.getFunctionRule()) {
					sequence_Function(context, (Function) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.FUNCTION_ARGUMENT_LIST:
				if(context == grammarAccess.getFunctionArgumentListRule()) {
					sequence_FunctionArgumentList(context, (FunctionArgumentList) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.INTEGER_OPTION:
				if(context == grammarAccess.getIntegerOptionRule() ||
				   context == grammarAccess.getOptionTypeRule()) {
					sequence_IntegerOption(context, (IntegerOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.OPTION:
				if(context == grammarAccess.getOptionRule()) {
					sequence_Option(context, (Option) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.OPTIONS:
				if(context == grammarAccess.getOptionsRule()) {
					sequence_Options(context, (Options) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.OPTIONS_PAGE:
				if(context == grammarAccess.getOptionsPageRule()) {
					sequence_OptionsPage(context, (OptionsPage) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.PLAIN_TYPE:
				if(context == grammarAccess.getFunctionTypeRule() ||
				   context == grammarAccess.getPlainTypeRule()) {
					sequence_PlainType(context, (PlainType) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.PLUGIN:
				if(context == grammarAccess.getPluginRule()) {
					sequence_Plugin(context, (Plugin) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.RANGE_OPTION:
				if(context == grammarAccess.getOptionTypeRule() ||
				   context == grammarAccess.getRangeOptionRule()) {
					sequence_RangeOption(context, (RangeOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.SELECT_OPTION:
				if(context == grammarAccess.getMultiChoiceOptionRule() ||
				   context == grammarAccess.getOptionTypeRule() ||
				   context == grammarAccess.getSelectOptionRule()) {
					sequence_SelectOption(context, (SelectOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.SELECT_PARAM:
				if(context == grammarAccess.getAbstractParamRule() ||
				   context == grammarAccess.getSelectParamRule()) {
					sequence_SelectParam(context, (SelectParam) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.SHORTCODE_TYPE:
				if(context == grammarAccess.getFunctionTypeRule() ||
				   context == grammarAccess.getShortcodeTypeRule()) {
					sequence_ShortcodeType(context, (ShortcodeType) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.STRING_OPTION:
				if(context == grammarAccess.getOptionTypeRule() ||
				   context == grammarAccess.getStringOptionRule()) {
					sequence_StringOption(context, (StringOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.STRING_PARAM:
				if(context == grammarAccess.getAbstractParamRule() ||
				   context == grammarAccess.getAbstractStringParamRule() ||
				   context == grammarAccess.getStringParamRule() ||
				   context == grammarAccess.getTextParamRule()) {
					sequence_StringParam(context, (StringParam) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.TEXT_OPTION:
				if(context == grammarAccess.getOptionTypeRule() ||
				   context == grammarAccess.getTextOptionRule()) {
					sequence_TextOption(context, (TextOption) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.TEXT_PARAM:
				if(context == grammarAccess.getAbstractParamRule() ||
				   context == grammarAccess.getAbstractStringParamRule() ||
				   context == grammarAccess.getTextParamRule()) {
					sequence_TextParam(context, (TextParam) semanticObject); 
					return; 
				}
				else break;
			case WpBenchPackage.URL_OPTION:
				if(context == grammarAccess.getOptionTypeRule() ||
				   context == grammarAccess.getURLOptionRule()) {
					sequence_URLOption(context, (URLOption) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (action=STRING priority=INT)
	 */
	protected void sequence_ActionType(EObject context, ActionType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.ACTION_TYPE__ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.ACTION_TYPE__ACTION));
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.ACTION_TYPE__PRIORITY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.ACTION_TYPE__PRIORITY));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getActionTypeAccess().getActionSTRINGTerminalRuleCall_1_0(), semanticObject.getAction());
		feeder.accept(grammarAccess.getActionTypeAccess().getPriorityINTTerminalRuleCall_2_0(), semanticObject.getPriority());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID title=STRING description=STRING?)
	 */
	protected void sequence_AdminPage(EObject context, AdminPage semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=BooleanParam param+=BooleanParam*)?)
	 */
	protected void sequence_BooleanOption(EObject context, BooleanOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID title=STRING?)
	 */
	protected void sequence_ChoiceFn(EObject context, ChoiceFn semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=ChoiceParam param+=ChoiceParam*)?)
	 */
	protected void sequence_ChoiceOption(EObject context, ChoiceOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     choice=ChoiceFn
	 */
	protected void sequence_ChoiceParam(EObject context, ChoiceParam semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.CHOICE_PARAM__CHOICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.CHOICE_PARAM__CHOICE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getChoiceParamAccess().getChoiceChoiceFnParserRuleCall_1_0(), semanticObject.getChoice());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=DefaultOptionParam param+=DefaultOptionParam*)?)
	 */
	protected void sequence_ColourOption(EObject context, ColourOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=CustomParam param+=CustomParam*)?)
	 */
	protected void sequence_CustomOption(EObject context, CustomOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (id=ID value=STRING)
	 */
	protected void sequence_CustomParamFn(EObject context, CustomParamFn semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.CUSTOM_PARAM_FN__ID) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.CUSTOM_PARAM_FN__ID));
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.CUSTOM_PARAM_FN__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.CUSTOM_PARAM_FN__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getCustomParamFnAccess().getIdIDTerminalRuleCall_0_0(), semanticObject.getId());
		feeder.accept(grammarAccess.getCustomParamFnAccess().getValueSTRINGTerminalRuleCall_2_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (className=STRING | customSettings+=CustomParamFn)
	 */
	protected void sequence_CustomParam(EObject context, CustomParam semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=DefaultOptionParam param+=DefaultOptionParam*)?)
	 */
	protected void sequence_DateOption(EObject context, DateOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     site?='site'
	 */
	protected void sequence_DefaultOptionParam(EObject context, DefaultOptionParam semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (filter=STRING priority=INT)
	 */
	protected void sequence_FilterType(EObject context, FilterType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.FILTER_TYPE__FILTER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.FILTER_TYPE__FILTER));
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.FILTER_TYPE__PRIORITY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.FILTER_TYPE__PRIORITY));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getFilterTypeAccess().getFilterSTRINGTerminalRuleCall_1_0(), semanticObject.getFilter());
		feeder.accept(grammarAccess.getFilterTypeAccess().getPriorityINTTerminalRuleCall_2_0(), semanticObject.getPriority());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=DefaultOptionParam param+=DefaultOptionParam*)?)
	 */
	protected void sequence_FloatOption(EObject context, FloatOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (args+=ID args+=ID*)
	 */
	protected void sequence_FunctionArgumentList(EObject context, FunctionArgumentList semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (type=FunctionType name=ID args=FunctionArgumentList? body=STRING?)
	 */
	protected void sequence_Function(EObject context, Function semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=DefaultOptionParam param+=DefaultOptionParam*)?)
	 */
	protected void sequence_IntegerOption(EObject context, IntegerOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID type=OptionType)
	 */
	protected void sequence_Option(EObject context, Option semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.OPTION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.OPTION__NAME));
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.OPTION__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.OPTION__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getOptionAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getOptionAccess().getTypeOptionTypeParserRuleCall_1_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID site?='site'? title=STRING header=STRING? (options+=[Option|ID]+ footer=STRING?)?)
	 */
	protected void sequence_OptionsPage(EObject context, OptionsPage semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (options+=Option*)
	 */
	protected void sequence_Options(EObject context, Options semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {PlainType}
	 */
	protected void sequence_PlainType(EObject context, PlainType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         imports+=STRING* 
	 *         (type='plugin' | type='library') 
	 *         name=ID 
	 *         platform=Platform? 
	 *         title=STRING 
	 *         version=STRING? 
	 *         pluginURI=STRING? 
	 *         description=STRING? 
	 *         author=STRING? 
	 *         skin=STRING? 
	 *         include+=STRING* 
	 *         script+=STRING* 
	 *         css+=STRING* 
	 *         script+=STRING* 
	 *         adminCSS+=STRING* 
	 *         options=Options? 
	 *         optionsPage+=OptionsPage* 
	 *         adminPages+=AdminPage* 
	 *         functions+=Function*
	 *     )
	 */
	protected void sequence_Plugin(EObject context, Plugin semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=DefaultOptionParam param+=DefaultOptionParam*)?)
	 */
	protected void sequence_RangeOption(EObject context, RangeOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=SelectParam param+=SelectParam*)?)
	 */
	protected void sequence_SelectOption(EObject context, SelectOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     select=ChoiceFn
	 */
	protected void sequence_SelectParam(EObject context, SelectParam semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.SELECT_PARAM__SELECT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.SELECT_PARAM__SELECT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSelectParamAccess().getSelectChoiceFnParserRuleCall_1_0(), semanticObject.getSelect());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     code=STRING
	 */
	protected void sequence_ShortcodeType(EObject context, ShortcodeType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.SHORTCODE_TYPE__CODE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.SHORTCODE_TYPE__CODE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getShortcodeTypeAccess().getCodeSTRINGTerminalRuleCall_1_0(), semanticObject.getCode());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=StringParam param+=StringParam*)?)
	 */
	protected void sequence_StringOption(EObject context, StringOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (max=INT | min=INT)
	 */
	protected void sequence_StringParam(EObject context, StringParam semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=TextParam param+=TextParam*)?)
	 */
	protected void sequence_TextOption(EObject context, TextOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     html?='html'
	 */
	protected void sequence_TextParam(EObject context, TextParam semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, WpBenchPackage.Literals.TEXT_PARAM__HTML) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, WpBenchPackage.Literals.TEXT_PARAM__HTML));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getTextParamAccess().getHtmlHtmlKeyword_1_0(), semanticObject.isHtml());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     ((param+=DefaultOptionParam param+=DefaultOptionParam*)?)
	 */
	protected void sequence_URLOption(EObject context, URLOption semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
}
